spring系列---SpringDataRedis使用

SpringDataRedis简介

1项目常见问题思考

当每天大量流量访问系统的时候会对系统早上大量的压力 解决方式之一就是缓存,另一种是网页静态化。今天我先贴出第一种方法的配置第二种方法日后再发布。

2 Redis官网介绍

redis是一款开源的Key-Value数据库，运行在内存中，由ANSI C编写。企业开发通常采用Redis来实现缓存。同类的产品还有memcache 、memcached 、MongoDB等。
本人的网络官网访问不了 先看中文的吧

3 Jedis

Jedis是Redis官方推出的一款面向Java的客户端，提供了很多接口供Java语言调用。可以在Redis官网下载，当然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。

4 Spring Data Redis

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis,  JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。

spring-data-redis针对jedis提供了如下功能：

1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类

2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

   • ValueOperations：简单K-V操作
   • SetOperations：set类型数据操作
   • ZSetOperations：zset类型数据操作
   • HashOperations：针对map类型的数据操作
   • ListOperations：针对list类型的数据操作

5 准备工作

（1）构建Maven工程 spring_data_redis_demo

（2）引入Spring相关依赖、引入JUnit依赖 （内容参考资料中配置文件）

（3）引入Jedis和SpringDataRedis依赖

• pom.xml

• <!-- 缓存 -->
         <dependency>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-redis</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-commons</artifactId>
             <version>1.8.4.RELEASE</version>
         </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-pool2</artifactId>
         </dependency>

• spring/applicationContext-redis.xml

• <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
              http://www.springframework.org/schema/beans/spring-beans.xsd   
              http://www.springframework.org/schema/context   
              http://www.springframework.org/schema/context/spring-context.xsd   ">
  
      <context:property-placeholder location="classpath*:properties/*.properties"/>
  
      <!-- redis 相关配置 -->
      <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
          <property name="maxIdle" value="${redis.maxIdle}"/>
          <property name="maxWaitMillis" value="${redis.maxWait}"/>
          <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
      </bean>
  
      <bean id="JedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
            p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/>
  
      <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
          <property name="connectionFactory" ref="JedisConnectionFactory"/>
      </bean>
  
  </beans>  

  • maxIdle ：最大空闲数
  • maxWaitMillis:连接时的最大等待毫秒数
  • testOnBorrow：在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的；
• properties/redis-config.properties 工具类

• # Redis settings 
  # server IP 
  redis.host=127.0.0.1
  # server port 
  redis.port=6379
  # server pass 
  redis.pass=
  # use dbIndex 
  redis.database=0
  # 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例
  redis.maxIdle=300
  #表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间(毫秒)，则直接抛出JedisConnectionException；
  redis.maxWait=3000
  # 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的  
  redis.testOnBorrow=true

• utils.RedisCache

• package utils;
  import java.io.ByteArrayInputStream; 
  import java.io.ByteArrayOutputStream; 
  import java.io.IOException; 
  import java.io.ObjectInputStream; 
  import java.io.ObjectOutputStream; 
    
  import org.springframework.cache.Cache; 
  import org.springframework.cache.support.SimpleValueWrapper; 
  import org.springframework.dao.DataAccessException; 
  import org.springframework.data.redis.connection.RedisConnection; 
  import org.springframework.data.redis.core.RedisCallback; 
  import org.springframework.data.redis.core.RedisTemplate;
  //    Redis缓存管理类
  // @author Administrator
  public class RedisCache implements Cache{
  
        private RedisTemplate<String, Object> redisTemplate;  
        private String name;  
        public RedisTemplate<String, Object> getRedisTemplate() { 
          return redisTemplate;  
        } 
           
        public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { 
          this.redisTemplate = redisTemplate;  
        } 
           
        public void setName(String name) { 
          this.name = name;  
        } 
           
        @Override 
        public String getName() { 
          // TODO Auto-generated method stub  
          return this.name;  
        } 
        
        @Override 
        public Object getNativeCache() { 
         // TODO Auto-generated method stub  
          return this.redisTemplate;  
        } 
         
        @Override 
        public ValueWrapper get(Object key) { 
         // TODO Auto-generated method stub 
         System.out.println("get key"); 
         final String keyf = key.toString(); 
         Object object = null; 
         
         
         object = redisTemplate.execute(new RedisCallback<Object>() { 
         public Object doInRedis(RedisConnection connection)  
               throws DataAccessException { 
           byte[] key = keyf.getBytes(); 
           byte[] value = connection.get(key); 
           if (value == null) { 
             return null; 
            } 
           return toObject(value); 
           } 
          }); 
          return (object != null ? new SimpleValueWrapper(object) : null); 
         } 
         
         @Override 
         public void put(Object key, Object value) { 
          // TODO Auto-generated method stub 
          System.out.println("put key"); 
          final String keyf = key.toString();  
          final Object valuef = value;  
          final long liveTime = 86400;  
          redisTemplate.execute(new RedisCallback<Long>() {  
            public Long doInRedis(RedisConnection connection)  
                throws DataAccessException {  
              byte[] keyb = keyf.getBytes();  
              byte[] valueb = toByteArray(valuef);  
              connection.set(keyb, valueb);  
              if (liveTime > 0) {  
                connection.expire(keyb, liveTime);  
               }  
              return 1L;  
             }  
           });  
         } 
        
         private byte[] toByteArray(Object obj) {  
           byte[] bytes = null;  
           ByteArrayOutputStream bos = new ByteArrayOutputStream();  
           try {  
            ObjectOutputStream oos = new ObjectOutputStream(bos);  
            oos.writeObject(obj);  
            oos.flush();  
            bytes = bos.toByteArray();  
            oos.close();  
            bos.close();  
           }catch (IOException ex) {  
              ex.printStackTrace();  
           }  
           return bytes;  
          }  
        
          private Object toObject(byte[] bytes) { 
           Object obj = null;  
            try { 
              ByteArrayInputStream bis = new ByteArrayInputStream(bytes);  
              ObjectInputStream ois = new ObjectInputStream(bis);  
              obj = ois.readObject();  
              ois.close();  
              bis.close();  
            } catch (IOException ex) {  
              ex.printStackTrace();  
            } catch (ClassNotFoundException ex) {  
              ex.printStackTrace();  
            }  
            return obj;  
          } 
         
          @Override 
          public void evict(Object key) {  
           // TODO Auto-generated method stub  
           System.out.println("del key"); 
           final String keyf = key.toString();  
           redisTemplate.execute(new RedisCallback<Long>() {  
           public Long doInRedis(RedisConnection connection)  
                throws DataAccessException {  
             return connection.del(keyf.getBytes());  
            }  
           });  
          } 
         
          @Override 
          public void clear() {  
            // TODO Auto-generated method stub  
            System.out.println("clear key"); 
            redisTemplate.execute(new RedisCallback<String>() {  
              public String doInRedis(RedisConnection connection)  
                  throws DataAccessException {  
               connection.flushDb();  
                return "ok";  
              }  
            });  
          } 
        
          @Override
          public <T> T get(Object key, Class<T> type) { 
            // TODO Auto-generated method stub 
            return null; 
          } 
          
          @Override
          public ValueWrapper putIfAbsent(Object key, Object value) { 
            // TODO Auto-generated method stub 
            return null; 
          } 
  }